Processor specific dispatching in a heterogeneous configuration

ABSTRACT

An abstraction layer is comprised in the operating system that represents the particulars of the PPMs. The abstractions in the abstraction layer are differentiated from one another by parameters representing the characteristics of the PPMs. The dispatcher uses the abstraction to balance processing loads when assigning execution threads to the PPMs. The assigning of the execution threads and the balancing of the processing loads is performed while taking account of the characteristics of the PPMs, such as shared resources and clock speed.

BACKGROUND

The effective throughput of a computer can be increased by using multiple Physical Processing Modules (PPMs) (a physical processing module is a chip or a die having one or more physical processing cores). In the past, multiple PPM systems were typically homogeneous in that they had one type of PPM, and each PPM had one physical processing core.

In the prior art, PPMs are seen by the software as one or more generic logical processing entities (e.g., schedulable entities) upon which a single execution thread may be scheduled to run. Historically, there has been a one-to-one mapping between PPMs and generic logical processing entities, and the PPMs existing in a given system have typically been homogeneous. Any resources (e.g., physical memory and data pathways) shared by PPMs and/or generic logical processing entities have been historically “off-chip,” meaning that the shared resources have not been located on the PPMs, but have been located elsewhere. In this specification the word “resource” and its conjugations refer to any resource or facility (whether or not it is associated with an amount or a supply that can be expended or filled), and the word facility and its conjugations may be interchanged with the word resource and its corresponding conjugations wherever they appear. Software (e.g., operating systems) that have been designed to work with traditional PPMs (and configurations thereof) may assume that (1) no special relationship exists (such as resource sharing) between PPMs (and therefore no special relationship exists between the corresponding generic logical processing entities) in a system, and (2) PPMs in a system have the same operational characteristics.

SUMMARY

The present invention provides several features that can each be used independently of one another or with any combination of the other features. Although many of the features of the present invention are motivated by the problems explained above, any individual feature may not address any of the problems discussed above or may only address one of the problems discussed above. Some of the problems discussed above may not be fully addressed by any of the features of the present invention.

An abstraction of a PPM is provided that characterizes the particulars of the PPM. In different embodiments, the abstractions may model the particulars of the PPMs to varying degrees. Each abstraction models at least some characteristics specific to a PPM. The abstractions may comprise parameterization information regarding the characteristics of the PPMs. To the extent that each PPM differs from one another and to the degree to which the particulars of the PPMs are comprised in the abstractions, the abstractions of the PPMs may be differentiated from one another by the differing characteristics of the PPM being modeled. In an embodiment, the abstractions comprise indications of how many logical processing entities are provided by the PPM. In an embodiment, the abstraction may additionally or instead comprise operational information indicating one or more operational characteristics of the PPM. Using the abstractions, the operating system is able to account for the differences in the PPMs and how the hardware threads and physical processing cores share resources. This in turn enables the operating system to treat different logical processing entities differently when dispatching threads to achieve a greater overall efficiency. The abstractions may have a variety of different types of clients, such as application programs or a dispatcher or other part of an operating system.

BRIEF DESCRIPTION OF THE DRAWINGS

The embodiments of the present invention are illustrated by way of example, and not limited by or to these examples, in the figures of the accompanying drawings, and in which like reference numerals refer to similar elements and in which:

FIG. 1A shows a block diagram of a homogeneous system having an operating system dispatching threads to multiple PPMs.

FIG. 1B shows a block diagram of a CMP module and associated logical processing entities.

FIG. 1C shows a block diagram of an SMT module and associated logical processing entities.

FIG. 1D shows a block diagram of a CMT module and associated logical processing entities.

FIG. 2A shows a block diagram of a system, having an operating system dispatching threads to multiple PPMs, according to an embodiment of the present invention.

FIG. 2B shows a block diagram of another view of the operating system of FIG. 2A, according to an embodiment of the invention.

FIG. 3 shows a block diagram of an example of PPMs that can be used in the system of FIG. 2A, according to an embodiment of the invention.

FIG. 4 shows a block diagram of an example of an abstraction of the abstraction layer of FIG. 2A, according to an embodiment of the invention.

FIG. 5 shows a block diagram of an example of a run queue load distribution subsystem of FIG. 2A, according to an embodiment of the invention.

FIG. 6 shows a flowchart of a method for running the operating system of FIG. 2A, according to an embodiment of the invention.

FIG. 7 shows a flowchart of a method for creating abstractions, according to an embodiment of the invention.

FIG. 8 shows a flowchart of a method for dispatching execution threads, according to an embodiment of the invention.

FIG. 9 shows a block diagram of a hardware overview of a computer system, which may be used to execute the operating system of FIG. 2A, according to an embodiment of the invention.

DETAILED DESCRIPTION OF EMBODIMENT(S)

In general in this specification, for each of FIGS. 1-5, first a brief description of each numbered feature of the figure is given. In the brief description of each numbered feature, essentially just the name of each numbered feature is given. Next, after the brief description of each numbered feature, follows a more detailed description of the each numbered feature and a description of how each of the features cooperate together. Each of the figures and features are generally discussed in the order in which they are numbered. Although headings are provided, information related to a particular heading, but not found in the section having that heading, may also be found elsewhere in the specification.

Functional Overview of Various Embodiments

In an embodiment, an abstraction layer is added to the operating system. The abstraction layer may include abstractions of PPMs. The abstractions are used by the operating system, while dispatching execution threads, to account for differences between the various PPMs in order to optimally balance the workload across the PPMs. In an embodiment, the operating system includes an abstraction manager for creating and/or managing the abstractions. In an embodiment, the operating system comprises a dispatcher, which access the abstractions to obtain information about the PPMs (e.g., information about operational characteristics and resource sharing) in order to decide which execution threads will be dispatched to which PPMs. In an embodiment, the abstractions are also utilized by the application layer to take into account the characteristics of and/or differences among the various PPMs to optimize its performance.

Overview of Dispatching Execution Threads in a Homogeneous System

In this specification, although several features are given a range “a-n,” the number “n” in each range (no matter where in this specification the range appears) may be any number. Thus, each range “a-n” may contain any number of elements, and each range “a-n” in this specification may be different or the same in number in comparison to any other range “a-n,” except for when a relation between two ranges “a-n” is specified.

FIG. 1A shows a block diagram of a system 100 having an operating system dispatching threads to multiple physical processing cores or hardware threads. System 100 comprises application layer 102, application threads 104, operating system 106, execution threads 108 a-n, and PPMs 110 a-n. Each of PPMs 110 a-n is represented to operating system 106 as one of generic logical processing entities 111 a-n. Operating system 106 comprises kernel 112, which in turn comprises dispatcher 114, execution threads 120, and run queues 124 a-n. PPMs 110 a-n comprise physical processing cores 126 a-n.

Application layer 102 comprises one or more applications that create application threads 104 as part of their normal operations, which are scheduled by operating system 106 as execution threads 108 a-n. The scheduling is performed by dispatcher 114 after receiving input regarding application threads 104 needing to be dispatched. Application threads 104 are execution threads generated by application 102. Each of application threads 104 corresponds to a task, routine, and/or object associated with application 102.

Dispatcher 114 dispatches application threads 104 as execution threads 120. Execution threads 120 may also comprise execution threads generated by operating system 106. Each of generic logical processing entities 111 a-n are the same, and represent one of the physical processing cores 126 a-n associated with PPMs 110 a-n. Each of generic logical processing entities 111 a-n may also be referred to as a schedulable entity, because each of generic logical processing entities 111 a-n is presented to operating system 106 as essentially a generic entity upon which threads can be scheduled for processing. PPMs 110 a-n and generic logical processing entities 111 a-n have a one-to-one correspondence. In other words, each of generic logical processing entities 111 a-n corresponds to one of PPMs, each of which contains just one physical processing core, which is one of physical processing cores 126 a-n. During the operation of operating system 106, generic logical processing entities 111 a-n are used by dispatcher 114 to schedule execution threads 120 on run queues 124 a-n, partially balancing the loads associated with execution threads 120 among PPMs 110 a-n. As each of PPMs 110 a-n is ready to accept another thread, it grabs the next of execution threads 108 a-n from the one of run queues 124 a-n with which it is associated. Since each of PPMs 10 a-n is essentially identical to the others of PPMs 110 a-n, operating system 106 can treat each of generic logical processing entities 111 a-n as being the same (e.g., having the same operational parameters such as clock speed and having the same available cache and TLB).

Overview of Some Newer PPM Types

Several types of PPMs exist, some examples of which are, Chip Multi-Processing modules (CMP modules), Simultaneous Multi-Threading modules (SMT modules), and Threaded CMP modules (CMT modules) shown in FIGS. 1B-D, respectively. These different types of PPMs can be implemented within the same system, which therefore is not homogeneous. Newer types of PPMs (e.g., CMP, SMT, and CMT) are different in that multiple generic processing entities may be presented by a single PPM, or single processing core. Therefore, multiple logical processing entities may “share” the use of certain resources. Additionally, different types of PPMs may co-exist in a single system, each having different operational characteristics.

FIG. 1B shows a block diagram of a CMP module 150 and associated logical processing entities 152 a and 152 b. CMP module 150 has physical processing entities 154 a and 154 b, which have caches 156 a and 156 b, physical processing cores 158 a and 158 b, and Translation Lookaside Buffers (TLBS) 160 a and 160 b, respectively. As an aside, in this specification a “physical processing entity” is used to refer to the combination of a single physical processing core and the resources that are dedicated to it alone, in contrast to a PPM, which refers to an entire chip or die, for example. Returning to this example, CMP module 150 also comprises shared cache 162. Although for simplicity only two physical processing cores (158 a and 158 b) and two logical processing entities (154 a and 154 b) are shown in FIG. 1 b, a CMP module can have any number of physical processing cores each associated with a corresponding logical processing entity.

CMP module 150 can process multiple execution threads concurrently using each of physical processing cores 154 a and 154 b to process a different execution thread. Each of physical processing cores 154 a and 154 b appears to operating system 106 as a generic logical processing entity (generic logical processing entities 152 a and 152 b, respectively) unrelated to any other logical processing entity. Although each of physical processing cores 158 a and 158 b have their own cache 156 a and 156 b and own TLBs 160 a and 160 b, and are therefore relatively independent, they may share shared cache 162.

FIG. 1C shows a block diagram of an SMT module 170 and associated logical processing entities 172 a-c. SMT module 170 has physical processing core 173 comprising hardware threads 174 a-c. SMT module 170 also has TLB 176 and shared cache 178 used by physical processing core 173. Although only three hardware threads 174 a-c and three logical processing entities 172 a-c are shown, an SMT module could have any number of hardware threads and logical processing entities.

In general in SMT modules, one physical processing core is shared by several hardware threads in which each hardware thread is represented by a corresponding logical processing entity. As indicated in FIG. 1C, each of hardware threads 174 a-c may be associated with a register state of physical processing core 173. Each of generic logical processing entities 172 a-c is associated with one of hardware threads 174 a-c, respectively, which share physical processing core 173. Physical processing core 173 can process multiple execution threads concurrently using each of hardware threads 174 a-c to process a different execution thread. In addition, in SMT module 173, each of hardware threads 174 a-c share TLB 176 and cache 178 of physical processing core 173. Hardware threads 174 a-c share a data pathway (not shown) with each other. Typically, in SMT modules nearly everything on the PPM is shared by the hardware threads. Each of hardware threads 174 a-c is presented to the operating system as a generic logical processing entity (generic logical processing entities 172 a-c), without specifying any of the shared resources (e.g., the shared data pathway, physical processing core 173, TLB 178, and cache 178).

FIG. 1D shows a block diagram of a CMT module 190 and associated logical processing entities 190 a-n. CMT module 190 has multiple physical processing cores 192 a-n, each comprising multiple hardware threads 196 a-n. (Thus, there are more hardware threads 196 a-n than physical processing cores 192 a-n.) In this example, CMT module 190 also has shared cache 194.

Hardware threads 196 a-n are distributed into groups, and each group shares one of physical processing cores 192 a-n. CMT module 190 can have any number of physical processing cores 192 a-n, and each of physical processing cores 192 a-n can have any number of hardware threads 196 a-n. Shared cache 194 is shared by all physical processing cores 192 a-n and their respective hardware threads 196 a-n. Each of hardware threads 192 a-n that is located on the same one of physical processing cores 192 a-n share a data pathway (not shown). Each one of hardware threads 196 a-n is presented to the operating system as a generic logical processing entity (generic logical processing entities 190 a-n) without specifying which of hardware threads 196 a-n share which of physical processing cores 192 a-n or the sharing of shared cache 194.

Overview of the Dispatching of Execution Threads in a Nonhomogeneous System

FIG. 2A shows a block diagram of a system 200, having an operating system dispatching threads to multiple PPMs, according to an embodiment of the invention. System 200 comprises application layer 202, application threads 204, operating system 206, run queue execution threads 208 a-n, logical processing entities 211 a-n, and PPMs 210 a-n. Operating system 206 comprises kernel 212, which comprises dispatcher 214, abstraction manager 216, execution threads 220, abstraction layer 222 having abstractions 222 a-n, and run queues 224 a-n. In alternative embodiments, system 200 may not comprise all of the features listed above and/or may contain additional features instead of or in addition to the features listed above.

Application layer 202 may be identical to application layer 102, and similarly may comprise one or more applications, each of which may comprise any number of objects and/or routines. For example, application layer 202 may comprise a word processing program, a spreadsheet, a program for developing applications, a database, and/or a server.

Application threads 204 may be identical to application threads 104, and in an embodiment (similar to application threads 104) application threads 204 are generated by application layer 202. In an embodiment, each of application threads 204 corresponds to a task, routine, and/or object associated with an application of application layer 202.

In an embodiment, operating system 206 is software that runs the applications of application layer 202, and acts as an interface between the application of application layer 202 and the hardware on which it resides, such as PPMs 210 a-n, memory units, input output devices, buses, and peripherals. In an embodiment, PPMs 210 a-n present themselves to operating system 206 as logical processing entities 211 a-n. There may be one or multiple logical processing entities for each of PPMs 210 a-n. An example of an embodiment of PPMs 210 a-n is discussed in conjunction with FIG. 3. Embodiment of other hardware is discussed further in conjunction with FIG. 9.

In an embodiment, kernel 212 comprises the core components that are essential to the operation of operating system 206. In an embodiment, one such component is dispatcher 214, which determines the manner in which run queue execution threads 208 a-n are dispatched. Dispatcher execution threads 220 have a correspondence to run queue execution threads 208 a-n. The correspondence between dispatcher execution threads 220 and run queue execution threads 208 a-n may be one-to-one, and dispatcher execution threads 220 may be identical to run queue execution threads 208 a-n differing only in that run queue execution threads 208 a-n have already been scheduled and may be in the process of being removed from run queues 224 a-n to be run on PPMs 210 a-n. Dispatcher execution threads 220 and run queue execution threads 208 a-n differ from application threads 204 in that dispatcher execution threads 220 and 208 a-n may comprise execution threads associated with the objects and/or routines of operating system 206. In an embodiment, dispatcher execution threads 220 may be just representations of run queue execution threads 208 a-n used for dispatching run queue execution threads 208 a-n to run queues 224 a-n. In an embodiment, the dispatching of dispatcher execution threads 220 determines a corresponding dispatch of run queue execution threads 208 a-n. Dispatcher 214 dispatches dispatcher execution threads 220 across PPMs 210 a-n to achieve an optimum balance of the workload. In an embodiment, dispatcher 214 updates abstractions 222 a-n with changes in the workload by for example, incrementing or decrementing a counter associated with abstractions 222 a-n, representing the number of threads in one of run queues 224 a-n and/or information related to a workload associated with one or PPMs 210 a-n. Dispatcher 214 differs from dispatcher 114 in that it is enabled to communicate with and take advantage of abstraction layer 222 and abstraction manager 216.

In an embodiment, abstraction manager 216 creates and manages abstractions 222 a-n, (which are abstractions of PPMs 210 a-n). In an embodiment, these are the only abstractions managed by abstraction manager 216. In an alternative embodiment, abstraction manager 216 may be part of another abstraction manager that manages other abstractions or may itself manage other abstractions. In creating abstractions 222 a-n, abstraction manager 216 interacts with PPMs 210 a-n, and/or stored data related to the characteristics of PPMs 210 a-n. Abstraction manager 216 may manage abstractions 222 a-n by updating parameters of abstractions 222 a-n as the processing load changes, for example. In managing abstractions 222 a-n, abstraction manager 216 may interact with run queues 224 a-n, and/or PPMs 210 a-n. In an alternative embodiment, abstraction manager 216 may update abstractions 222 a-n regarding the workload associated with each run queue and/or PPM instead of, or in addition to, the update performed by dispatcher 216. In an embodiment, abstraction manager 216 may be a separate module from dispatcher 214 as shown in FIG. 2A, or may located within dispatcher 214.

In an embodiment, abstractions 222 a-n are abstractions of, and have a correspondence to, PPMs 210 a-n, which may be, but are not limited to, a one-to-one correspondence. In an embodiment, at least part of the way that abstractions 222 a-n characterize PPMs 210 a-n is by comprising parameters characterizing various characteristics associated with PPMs 210 a-n. In an embodiment, the parameters of abstractions 222 a-n correspond to the load capacity, performance capabilities, and the resources available to each of the logical processing entities of PPMs 210 a-n, for example. In an embodiment, the parameters of abstractions 222 a-n differentiate abstractions 222 a-n from one another and reflect at least one of, some of, or all of the differences between the logical processing entities as determined by their PPMs 208 a-n. Abstractions 222 a-n may comprise other parameters characterizing PPMs 210 a-n. The parameters and structure of embodiments of abstractions 222 a-n are also discussed below in connection with FIG. 4. In an embodiment, abstractions 222 a-n allow dispatcher 214 to determine an optimum distribution of threads by balancing the loads associated with running each thread on each of PPMs 210 a-n while taking into account the distribution of run queues 224 a-n, the sharing of resources, and other parameters that affect scheduling considerations, characterized by the parametric information of abstractions 222 a-n.

Abstractions 222 a-n may be data structures or in an alternative embodiment may be objects that actively update themselves and/or participate in the scheduling of execution threads 220. Each of abstractions 222 a-n may be a separate data structure, or abstraction layer 222 may be one data structure having each of abstractions 222 a-n as separate portions. Using abstractions 222 a-n, dispatcher 214 schedules dispatcher execution threads 220 on run queues 224 a-n. More details of embodiments of operating system 206 are discussed below in conjunction with FIG. 2B.

In one embodiment, run queues 224 a-n are buffers for storing run queue execution threads 208 a-n. In one embodiment, run queues 224 a-n may be First In First Out (FIFO) buffers. In an embodiment, when each of PPMs 210 a-n is ready to accept another one of run queue execution threads 208 a-n to run, the PPM goes to one of run queues 224 a-n to determine the next execution thread to run, and processes the corresponding execution thread. PPMs 210 a-n may comprise any combination of different types of PPMs, which may differ in the number threads they can handle, the number of physical processing cores, the resources such as cache allocated to each physical processing core, the clock speed, and/or the type of PPM for example. Any of run queues 224 a-n may service one or multiple logical processing entities. Although in FIG. 2A only PPM 210 n has more than one of run queues 224 a-n servicing it, any given one of run queues 224 a-n may service only some of the logical processing entities of a PPM, and/or any given one of run queues 224 a-n may service multiple PPMs (and their associated logical processing entities).

More Details of an Embodiment of the Operating System

FIG. 2B shows a block diagram of another view of an embodiment of operating system 206, which comprises hardware independent portion 250 and hardware dependent portions 252 a-n. Hardware independent portion 250 comprises the dispatcher 214, the abstraction manager 216, and the abstraction layer 222 discussed above in conjunction with FIG. 2A. In alternative embodiments, operating system 206 may not comprise all of the features listed above and/or may contain additional features instead of or in addition to the features listed above.

In an embodiment, hardware dependent portions 252 a-n each interface with one or more specific pieces of hardware. In an embodiment, at least some of hardware dependent portions 252 a-n interface with PPMs 210 a-n. In an embodiment, abstraction manager 216 accesses PPMs 210 a-n via at least some of hardware dependent portions 252 a-n to obtain parametric information about physical modules 210 a-n, such as the clock speed, the number of physical processing cores, the number of hardware threads, and shared resource information (e.g., if a cache, data pathway, TLB, or other resource is shared). In an embodiment, abstraction manager 216 accesses hardware dependent portions 252 a-n prior to and/or while constructing abstractions 222 a-n. The information obtained comprises information related to characteristics of PPMs 210 a-n, and is used for constructing abstractions 222 a-n. In an alternative embodiment, abstraction manager 216 may also access PPMs 210 a-n, via hardware dependent portions 252 a-n, while dispatcher execution threads 220 are being dispatched, and the information obtained may also comprise dynamic or changing information that relates to the current states of the PPMs 210 a-n and their availability to process new execution threads.

Example of PPMs 210 a-n

FIG. 3 shows a block diagram of an example of PPMs 210 a-n, associated logical processing entities 302 a and 302 b, 312 a-c, and 320 a-n, and run queues 208 a-n. In this example, PPMs 210 a-c are CMP module 210 a, SMT module 210 b, and CMT module 210 c, respectively. CMP module 210 a is associated with logical processing entities 302 a and 302 b, and CMP module 210 a comprises physical processing entities 304 a and 304 b, and shared cache 306. Physical processing entities 304 a and 304 b have caches 306 a and 306 b, physical processing cores 308 a and 308 b, and TLBs 310 a and 310 b, respectively. SMT module 210 b comprises logical processing entities 312 a-c, hardware threads 314 a-c, TLB 316, and cache 318. CMT module 210 c has logical processing entities 320 a-n, physical processing cores 322 a-n, and cache 324. Comprised in physical processing cores 322 a-n are hardware threads 326 a-n. The remaining PPMs and run queues of PPMs 210 a-n are not shown. Other embodiment of PPMs 210 a-n may not have all of the features listed above, or may have other features in addition to and/or instead of those listed above.

Only a small number of physical processing cores, hardware threads, and their corresponding logical processing entities are illustrated in order to simplify FIG. 3. However, there may be any number of PPMs each having any number of hardware threads, physical processing cores, related components, and/or other components. FIG. 3 is just one example of a configuration of PPMs. Similarly, CMP module 210 a, SMT module 210 b, and CMT module 210 c are each just one example of a CMP, an SMT, and a CMT module, respectively. CMP module 210 a, SMT module 210 b, and CMT module 210 c may be identical to CMP module 150, SMT module 170, and CMT module 190, respectively. Alternatively, CMP module 210 a, SMT module 210 b, and CMT module 210 c and CMP module 150, SMT module 170, and CMT module 190, respectively may differ in the number of physical processing cores, hardware threads, and resources shared. The example, of FIG. 3 illustrates some of the variety of different types of PPMs that PPMs 210 a-n may comprise, which operating system 206 can handle efficiently. Additionally, FIG. 3 is an example of some of the variety of ways in which resources are shared.

As examples of resource sharing, shared cache 306 is a shared resource of logical processing entities 302 a and 302 b of CMP module 210 a. Alternative embodiments CMP module 210 a may not comprise shared cache 306 and/or may comprise a shared data pathway. TLB 316, cache 318, the physical processing core 313, and nearly all resources of SMT module 210 b are shared resources of hardware threads 314 a-c and therefore are shared resources of logical processing entities 312 a-c.

As additional examples of resource sharing, in CMT module 210 c, in an embodiment, there is one logical processing entity for each hardware thread 326 a-n. Each group of hardware threads 326 a-n and their corresponding logical processing entities 320 a-n of CMT module 210 c share one of physical processing cores 320 a-n. Additionally, in an embodiment, all hardware threads 326 a-n and their corresponding logical processing entities 320 a-n share cache 324 (no matter which of physical processing cores 326 a-n they share). In alternative embodiments, each physical processing core 320 a-n may have its own TLB and/or cache shared among its threads. Alternative embodiments of CMT module 210 c may not comprise shared cache 324 and/or may comprise a shared data pathway.

Physical processing cores 304 a and 304 b of CMP module 210 a, physical processing cores 314 a-c of SMT module 210 b, and hardware threads 326 a-n of CMT module 210 c interface with operating system 206 and its run queues 208 a-n via logical processing entities 302 a and 302 b, 312 a-c, and 320 a-n, for example. The manner of operation of CMP module 210 a, SMT module 210 b, and CMT module 210 c are understood by those of ordinary skill in the art, and further details will not be given here.

Structure of Embodiments of Abstractions

FIG. 4 shows a block diagram of an abstraction 400. Abstraction 400 comprises a representation of run queue 402, a representation of logical processors 404 a and 404 b, a pointer to processor specific routines 408, and representations of other characteristics 410. In alternative embodiments, abstraction 400 may not comprise all of the features listed above and/or may contain additional features instead of or in addition to the features listed above.

Abstraction 400 is an example of an embodiment of one of abstractions 222 a-n. Representation of run queue 402 represents one or more of run queues 224 a-n. In an embodiment, abstractions store information defined by a relationship (e.g., sharing) between the logical processing entities presented by the PPMs. Abstractions may additionally or alternatively store information defined by operational characteristics of and/or associated with a particular PPM. In an embodiment, the relationship and/or operational characteristics allow clients of the abstraction to access information regarding, and benefit from, the sharing relationships between logical processing entities, such as which resources are shared by whom. In an embodiment, the relationship and/or operational characteristics allow clients of the abstraction to access information regarding which logical processing entities map to which PPMs. In an embodiment, the relationship and/or operational characteristics allow clients of the abstraction to access the salient operational characteristics of a particular PPM. In an embodiment, the relationship and/or operational characteristics allow the dispatcher, in particular, to achieve a better utilization of resources, to better perform load balancing and to make better use of an execution thread's data investment in shared or other caches.

In an embodiment, representation of run queue 402 may comprise information such as which of PPMs 210 a-n is associated with the run queues of run queues 222 a-n being represented by representation of run queue 402. Representation of run queue 402 may comprise information about the capacity of the corresponding one of run queues 224 a-n, such as how many execution threads it can each accept, and how many execution threads are currently in the run queue corresponding to representation of run queue 402.

In an embodiment, representation of logical processing entities 404 a and 404 b represent the logical processing entities of the one or more of PPMs 210 a-n corresponding to abstraction 400. In an embodiment, representations of logical processing entities 404 a and 404 b may comprise information such as whether the corresponding logical processing entity is available for accepting a new thread, and information related to which PPM and run queue the corresponding one of logical processing entities 320 a-n is associated. Although two representations of logical processing entities are illustrated, abstraction 400 may contain any number of representations of logical processing entities.

In an embodiment, pointer to processor specific routines 408 may comprise one or more pointers to one or more scheduling routines or other routines, which may be stored elsewhere. (The actual processor specific routines are not shown.) For example, the processor specific routines may be stored in main memory (discussed below in conjunction with the hardware overview of FIG. 9), and may be transferred to a dynamic memory and/or a local cache while the hardware specific routine is running. In an embodiment, representation of other characteristics 410 may comprise the remaining parameters of abstraction 400, which may comprise variables that change as the load on and/or resources available to PPMs 208 a-n changes. Some examples of possible parameters for abstractions 222 a-n are clock speed, the number of cores, the number of logical processing entities (the number of concurrent threads that can be handled), and/or chip architecture. Some examples of chip architecture that may be comprised as parameters are the type of chip such as CMT, CMP, or SMT, and/or shared resources. Some examples of resources that may be shared are an arithmetic unit, a cache, a Translation Lookaside Buffer (TLB), another buffer, and/or another memory. Some more examples of shared resources that may be indicated by parameters are whether the chip contains two logical processing entities sharing one physical processor. The sharing of run queues may also be indicated in the parameters of abstraction 400. In an embodiment, application layer 202 may be a client of abstractions 222 a-n in addition to or instead of dispatcher 214. In an embodiment, using abstractions 222 a-n, applications 202 can decide which routines or threads to direct towards which processors and/or otherwise better manage the resources of PPM 210 a-n available to it.

Run Queue Distribution of Load

FIG. 5 shows, as an example, a block diagram of a run queue load distribution subsystem 500, comprising run queue 502, PPMs 504 and 506, and shared resource 508. In alternative embodiments, run queue load distribution subsystem 500 may not comprise all of the features listed above and/or may contain additional features instead of or in addition to the features listed above.

Run queue 502 is an example of one of run queues 224 a-n servicing multiple ones of PPMs 210 a-n, which in this example are PPMs 504 and 506. The first of PPM 504 or 506 that is ready to accept another thread, grabs the next execution thread associated with run queue 502. In an embodiment, the grouping of PPMs 210 a-n to run queues 224 a-n is at least in part dependent upon the sharing of resources. In the present example, PPMs 504 and 506 share a resource labeled shared resource 508, which may be a shared cache, a shared TLB or a shared data pathway, for example. In an embodiment, run queues 224 a-n of this example were set up such that PPMs 504 and 506 share run queue 502, because PPMs 504 and 506 share shared resource 508. The shared resource 508 may place a limit on the number of threads the combination of physical processors 504 and 506 can handle or may introduce scheduling requirements necessary to take advantage of a current configuration of the shared resource, such as the information already stored in a cache if the shared resource is cache.

In an embodiment, the distribution of run queues 224 a-n is chosen to optimize the load balancing among PPMs 210 a-n, and performs one part of the load balancing, thereby reducing the computations associated with the part of the load balancing (a second part) performed by dispatcher 214. In other words, in an embodiment, the load balancing is performed in two parts in which the first part is performed by dispatcher 214 and the second part is performed by the distribution of run queues 224 a-n. The use of the two part load balancing facilitates a quicker dispatching process, which is optimally load-balanced.

In an embodiment, the abstractions 222 a-n may have a one-to-one correspondence to run queues 224 a-n. In an embodiment, each abstraction of abstractions 222 a-n may be an abstraction of the combined characteristics of PPMs 208 a-n that are assigned to the run queue of run queues 224 a-n that corresponds the abstraction in question. In an embodiment, in this manner, a two part load balancing can also be efficiently accomplished.

The Operation of System 200

FIG. 6 shows a flowchart of an embodiment of a method 600 for running the operation of the operating system 206. Decision 602 and step 604 are optional. In an embodiment having decision 602, a determination is made in decision 602 whether run queues 222 a-n have been allocated. If run queues 224 a-n have not been allocated, dispatcher 216 or another module allocates run queues 224 a-n, and the method continues with decision box 606. Run queues 224 a-n are distributed among PPMs 210 a-n such that at least some of those of PPMs 210 a-n that have shared common resources also share run queues 224 a-n, thereby performing one part of the optimization of the balancing of the load associated with running run queue execution threads 208 a-n. If run queues 224 a-n have been allocated, method 600 continues with decision box 606, skipping step 604. In an embodiment, in decision 606, a determination is made whether abstractions 222 a-n exist, and/or whether abstractions 222 a-n agree with the most recent upgrade of PPMs 210 a-n. If abstractions 222 a-n do not exist or have not been updated to agree with the most recent upgrades to PPMs 210 a-n, in an embodiment, the method continues with step 608 in which abstractions 222 a-n are created or updated as shown in method 700 of FIG. 7, below, and then method 600 continues with step 610. In an embodiment, if abstractions do exist and have been updated, method 600 continues with step 610, skipping step 608. After decision 606 or step 608, in step 610, dispatcher 212 dispatches run queue execution threads 208 a-n, according to method 800 of FIG. 8.

Method 600 may only need to be performed once after the physical installation of new or additional PPMs 210 a-n, or after the upgrading of or the addition of more run queues 224 a-n. Alternatively, method 600 may be performed each time application threads need to be dispatched.

FIG. 7 shows a flowchart of an embodiment of a method 700 for creating abstractions 222 a-n. If abstractions 222 a-n have not been created, control is passed from dispatcher 214 to abstraction manager 216 for implementation of method 700. In an embodiment, in step 702, abstraction manager 216 checks PPMs 210 a-n and/or data stored comprising parameters related to PPMs 210 a-n to obtain parameters (i.e., receive parametric information) appropriate to characterize each of PPMs 210 a-n. In an embodiment, in step 704, abstraction manager 216 checks run queues 224 a-n or information stored about run queues 224 a-n, and makes a determination of the distribution of run queues 224 a-n with respect to PPMs 210 a-n. In an embodiment, in step 706, using the information gathered regarding the modeling of PPMs 210 a-n and run queues 224 a-n, abstraction manager 216 creates abstractions 222 a-n.

FIG. 8 shows a flowchart of an embodiment of a method 800 for dispatching execution threads. In an embodiment, in step 802, dispatcher 214 accesses abstractions 222 a-n to get information about PPMs 210 a-n. In an embodiment, in step 804, a determination is made about thread assignment. Step 804 comprises sub-steps 806 and 808. In an embodiment, in sub-step 806, a determination is made by dispatcher 214 whether to assign one of execution threads 220. The determination of whether to assign one of dispatcher execution threads 220 may be based on abstractions 222 a-n, the current overall processing load, and/or whether there are any applications running and generating applications threads 204. In an embodiment, in sub-step 808, a determination is made by dispatcher 214 using abstractions 222 a-n regarding where to assign one or more dispatcher execution threads 220 among PPMs 210 a-n, thereby determining to which of run queues 222 a-n to assign one of execution threads 220. In an embodiment, the abstractions 222 a-n are used in this determination to optimally balance the loads associated with dispatcher execution threads 220 among run queues 224 a-n, thereby accomplishing one part of the load balancing of threads 208 a-n. For those of abstractions 222 a-n having pointers to hardware specific routines (if any such abstractions exist), the hardware specific routines are executed as part of determining where to assign one or more of execution threads 220. In an embodiment, in step 810, dispatcher execution threads 220 are assigned. As each of PPMs 210 a-n is ready to accept another thread, it grabs the next execution thread in a queue associated with the one of run queues 224 a-n assigned to that PPM.

Hardware Overview

In one embodiment, the various components shown in FIG. 2 (e.g., dispatcher 214, abstraction manager 216, and abstractions layer 222) are implemented by sets of instructions executable by one or more processors of PPMs 210 a-n. These components may be implemented as part of an object oriented programming system, comprising but not limited to the JAVA™ programming system manufactured by Sun Microsystems, Inc., C, C++, compiled languages, interpreted languages, assembly language, or machine language. FIG. 9 shows a block diagram of a hardware overview of a computer system 900, which may be used to execute these components. Computer system 900 comprises a bus 902 or other communication mechanism for communicating information, and a processing unit 904 coupled with bus 902 for processing information. Processing unit 904 comprises PPMs 210 a-n. Computer system 900 also comprises a main memory 906, such as a random access memory (RAM) or other dynamic storage device, coupled to bus 902 for storing information and instructions to be executed by processing unit 904. Main memory 906 may also be further used to store temporary variables or other intermediate information during execution of instructions by processing unit 904. Computer system 900 further comprises a read only memory (ROM) 908 or other static storage device coupled to bus 902 for storing static information and instructions for processing unit 904. A storage device 910, such as a magnetic disk or optical disk, is provided and coupled to bus 902 for storing information and instructions.

Computer system 900 may be coupled via bus 902 to a display 912, such as a cathode ray tube (CRT), for displaying information to a computer user. An input device 914, comprising alphanumeric and other keys, is coupled to bus 902 for communicating information and command selections to processing unit 904. Another type of user input device is cursor control 916, such as a mouse, a trackball, or cursor direction keys for communicating direction information and command selections to processing unit 904 and for controlling cursor movement on display 912. This input device typically has two degrees of freedom in two axes, a first axis (e.g., x) and a second axis (e.g., y), that allows the device to specify positions in a plane.

According to one embodiment, the functionality of the present invention is provided by computer system 900 in response to processing unit 904 executing one or more sequences of one or more instructions contained in main memory 906. Executing the sequences of instructions may be performed by running run queue execution threads 208 a-n and on PPMs 210 a-n of processing unit 904. Thus, comprised in run queue execution threads 208 a-n are execution threads for operating system 206, such as execution thread related to dispatcher 214 and/or abstraction manager 216. Such instructions may be read into main memory 906 from another computer-readable medium, such as storage device 910. Execution of the sequences of instructions contained in main memory 906 causes processing unit 904 to perform the process steps described herein. In alternative embodiments, hard-wired circuitry may be used in place of or in combination with software instructions to implement the invention. Thus, embodiments of the invention are not limited to any specific combination of hardware circuitry and software.

The term “computer-readable medium” as used herein refers to any medium that participates in providing instructions to processing unit 904 for execution. Such a medium may take many forms, comprising non-volatile media and/or volatile media. Non-volatile media comprises, for example, optical or magnetic disks, such as storage device 910. Volatile media comprises dynamic memory, such as main memory 906.

Common forms of computer-readable media comprise, for example, a floppy disk, a flexible disk, a hard disk, a magnetic tape, or any other magnetic medium, a CD-ROM, any other optical medium, punch cards, paper tape, any other physical medium with patterns of holes, a RAM, a PROM, and EPROM, a FLASH-EPROM, any other memory chip or cartridge, or any other storage medium from which a computer can read.

Various forms of computer readable media may be involved in carrying one or more sequences of one or more instructions to processing unit 904 for execution. For example, the instructions may initially be carried on a magnetic disk of a remote computer. The remote computer can load the instructions into its dynamic memory and send the instructions to computer system 900. Bus 902 of computer system 900 carries the data to main memory 906, from which processing unit 904 retrieves and executes the instructions. The instructions received by main memory 906 may optionally be stored on storage device 910 either before or after execution by processing unit 904.

Computer system 900 also comprises a communication interface 918 coupled to bus 902. Communication interface 918 provides a two-way data communication coupling to a network link 920 that is connected to a local network 922. For example, communication interface 918 may be an integrated services digital network (ISDN) card or a modem to provide a data communication connection to a corresponding type of telephone line. As another example, communication interface 918 may be a local area network (LAN) card to provide a data communication connection to a compatible LAN. Wireless links may also be implemented. In any such implementation, communication interface 918 sends and receives electrical, electromagnetic or optical signals that carry digital data streams representing various types of information.

Network link 920 typically provides data communication through one or more networks to other data devices. For example, network link 920 may provide a connection through local network 922 to a host computer 924 or to data equipment operated by an Internet Service Provider (ISP) 926. ISP 926 in turn provides data communication services through the world wide packet data communication network now commonly referred to as the “Internet” 928. Local network 922 and Internet 928 both use electrical, electromagnetic or optical signals that carry digital data streams. The signals through the various networks and the signals on network link 920 and through communication interface 918, which carry the digital data to and from computer system 900, are examples of forms of carrier waves transporting the information.

Computer system 900 can send messages and receive data, comprising program code, through the network(s), network link 920 and communication interface 918. In the Internet example, a server 930 might transmit a requested code for an application program or other code, such as code for operating system 206, dispatcher 214, and/or abstraction manager 216, through Internet 928, ISP 926, local network 922 and communication interface 918. The received code may be executed by processing unit 904 as it is received, and/or stored in storage device 910, or other non-volatile storage for later execution. In this manner, computer system 900 may obtain application or other code in the form of a carrier wave.

At this point, it should be noted that although the invention has been described with reference to various embodiments, it should not be construed to be so limited. Various modifications may be made by those of ordinary skill in the art with the benefit of this disclosure without departing from the spirit of the invention. Thus, the invention should not be limited by the specific embodiments used to illustrate it but only by the scope of the issued claims. 

1. A method performed by an operating system executing within a computer system having different types of physical processing modules, the method comprising: receiving a first set of parametric information pertaining to a first physical processing module (PPM), the first PPM having a first architecture; constructing a first abstraction of the first PPM based, at least partially, upon the first set of parametric information, the first abstraction comprising an indication of how many logical processing entities are provided by the first PPM, the first abstraction further comprising operational information indicating one or more operational characteristics of the first PPM; determining that a second abstraction for a second PPM does not exist the second PPM having a second architecture, wherein the first architecture is different from the second architecture; receiving a second set of parametric information pertaining to the second PPM; constructing the second abstraction of the second PPM based, at least partially, upon the second set of parametric information, the second abstraction comprising an indication of how many logical processing entities are provided by the second PPM, the second abstraction further comprising operational information indicating one or more operational characteristics of the second PPM, wherein the second abstraction is different from the first abstraction to reflect at least one difference between the first architecture of the first PPM and the second architecture of the second PPM; and dispatching, based on the at least one difference between the first architecture of the first PPM and the second architecture of the second PPM and the operational information in the first abstraction, an execution thread for execution to one of the logical processing entities of the first PPM.
 2. The method of claim 1, wherein the first PPM comprises a first physical processing core which supports a single hardware thread, wherein the second PPM comprises a second physical processing core which supports a plurality of hardware threads, wherein constructing the first abstraction comprises indicating the first physical processing core as a single logical processing entity, and wherein constructing the second abstraction comprises indicating the second physical processing core as a plurality of logical processing entities.
 3. The method of claim 2, wherein constructing the second abstraction comprises indicating that the plurality of logical processing entities corresponding to the second physical processing core share one or more resources of the second PPM.
 4. The method of claim 1, wherein the first PPM has an n number of processing cores, where n is an integer greater than one, each of the n processing cores capable of supporting one hardware thread; and wherein the second PPM has a single processing core capable of supporting an m number of hardware threads, where m is an integer greater than one.
 5. The method of claim 4, wherein the first abstraction indicates that the first PPM provides an n number of logical processing entities, and wherein the second abstraction indicates that the second PPM provides an m number of logical processing entities.
 6. The method of claim 5, wherein the operational information of the first abstraction includes resource sharing information indicating one or more resources shared by the n logical processing entities of the first PPM, and wherein the operational information of the second abstraction includes resource sharing information indicating one or more resources shared by the m logical processing entities of the second PPM.
 7. The method of claim 6, wherein the resource sharing information of the first abstraction indicates that the n logical processing entities of the first PPM share a cache, and wherein the resource sharing information of the second abstraction indicates that the m logical processing entities of the second PPM share one or more of the following: a processing core, a data pathway, a translation lookaside buffer, and a cache.
 8. The method of claim 1, wherein the first PPM has an n number of processing cores, where n is an integer greater than one, each of the n processing cores capable of supporting one hardware thread; and wherein the second PPM has an m number of processing cores, wherein m is an integer greater than one, each of the m processing cores capable of supporting a p number of hardware threads, where p is an integer greater than one.
 9. The method of claim 8, wherein the first abstraction indicates that the first PPM provides an n number of logical processing entities, and wherein the second abstraction indicates that the second PPM provides an s number of logical processing entities, where s=m times p.
 10. The method of claim 9, wherein the operational information of the first abstraction includes resource sharing information indicating one or more resources shared by then logical processing entities of the first PPM, and wherein the operational information of the second abstraction includes resource sharing information indicating one or more resources shared by at least some of the s logical processing entities of the second PPM.
 11. The method of claim 10, wherein the resource sharing information of the first abstraction indicates that the n logical processing entities of the first PPM share a cache, and wherein the resource sharing information of the second abstraction indicates that at least some of the s logical processing entities of the second PPM share one or more of the following: a processing core, a data pathway, a translation lookaside buffer, and a cache.
 12. The method of claim 1, wherein the first PPM has a single processing core capable of supporting an n number of hardware threads, where n is an integer greater than one; and wherein the second PPM has an m number of processing cores, wherein m is an integer greater than one, each of the m processing cores capable of supporting a p number of hardware threads, where p is an integer greater than one.
 13. The method of claim 12, wherein the first abstraction indicates that the first PPM provides an n number of logical processing entities, and wherein the second abstraction indicates that the second PPM provides an s number of logical processing entities, where s=m times p.
 14. The method of claim 13, wherein the operational information of the first abstraction includes resource sharing information indicating one or more resources shared by the n logical processing entities of the first PPM, and wherein the operational information of the second abstraction includes resource sharing information indicating one or more resources shared by at least some of the s logical processing entities of the second PPM.
 15. The method of claim 14, wherein the resource sharing information of the first abstraction indicates that the n logical processing entities of the first PPM share one or more of the following: a processing core, a data pathway, a translation lookaside buffer, and a cache, and wherein the resource sharing information of the second abstraction indicates that at least some of the s logical processing entities of the second PPM share one or more of the following: a processing core, a data pathway, a translation lookaside buffer, and a cache.
 16. The method of claim 1, further comprising: accessing the first abstraction and/or the second abstraction.
 17. The method of claim 16, wherein the operational information of the first abstraction includes resource sharing information indicating one or more resources shared by the logical processing entities of the first PPM, and wherein the operational information of the second abstraction includes resource sharing information indicating one or more resources shared by the logical processing entities of the second PPM.
 18. The method of claim 17, wherein determining whether to dispatch an execution thread comprises: determining, based at least partially upon the resource sharing information in the first abstraction and/or the resource sharing information in the second abstraction, whether to dispatch an execution thread to one of the logical processing entities of the first PPM or one of the logical processing entities of the second PPM to be executed thereby.
 19. The method of claim 18, wherein the resource sharing information in the first abstraction indicates that the logical processing entities of the first PPM are sharing one or more of the following: a processing core, a data pathway, a translation lookaside buffer, and a cache.
 20. The method of claim 19, wherein the resource sharing information in the second abstraction indicates that the logical processing entities of the second PPM are sharing one or more of the following: a processing core, a data pathway, a translation lookaside buffer, and a cache.
 21. A computer readable medium carrying instructions for an operating system, wherein the instructions, when executed in a computer system, cause the computer system to perform the operations of: receiving a first set of parametric information pertaining to a first physical processing module (PPM), the first PPM having a first architecture; constructing a first abstraction of the first PPM based, at least partially, upon the first set of parametric information, the first abstraction comprising an indication of how many logical processing entities are provided by the first PPM, the first abstraction further comprising operational information indicating one or more operational characteristics of the first PPM; determining that a second abstraction for a second PPM does not exist, the second PPM having a second architecture, wherein the first architecture is different from the second architecture; receiving a second set of parametric information pertaining to the second PPM; constructing a second abstraction of the second PPM based, at least partially, upon the second set of parametric information, the second abstraction comprising an indication of how many logical processing entities are provided by the second PPM, the second abstraction further comprising operational information indicating one or more operational characteristics of the second PPM, wherein the second abstraction is different from the first abstraction to reflect at least one difference between the first architecture of the first PPM and the second architecture of the second PPM; and dispatching, based on the at least one difference between the first architecture of the first PPM and the second architecture of the second PPM and the operational information in the first abstraction, an execution thread for execution to one of the logical processing entities of the first PPM.
 22. The computer readable medium of claim 21, wherein the first PPM comprises a first physical processing core which supports a single hardware thread, wherein the second PPM comprises a second physical processing core which supports a plurality of hardware threads, wherein constructing the first abstraction comprises indicating the first physical processing core as a single logical processing entity, and wherein constructing the second abstraction comprises indicating the second physical processing core as a plurality of logical processing entities.
 23. The computer readable medium of claim 21, wherein constructing the second abstraction comprises indicating that the plurality of logical processing entities corresponding to the second physical processing core share one or more resources of the second PPM.
 24. The computer readable medium of claim 21, wherein the first PPM has an n number of processing cores, where n is an integer greater than one, each of the n processing cores capable of supporting one hardware thread; and wherein the second PPM has a single processing core capable of supporting an m number of hardware threads, where m is an integer greater than one.
 25. The computer readable medium of claim 24, wherein the first abstraction indicates that the first PPM provides an n number of logical processing entities, and wherein the second abstraction indicates that the second PPM provides an m number of logical processing entities.
 26. The computer readable medium of claim 25, wherein the operational information of the first abstraction includes resource sharing information indicating one or more resources shared by the n logical processing entities of the first PPM, and wherein the operational information of the second abstraction includes resource sharing information indicating one or more resources shared by the m logical processing entities of the second PPM.
 27. The computer readable medium of claim 26, wherein the resource sharing information of the first abstraction indicates that the n logical processing entities of the first PPM share a cache, and wherein the resource sharing information of the second abstraction indicates that the m logical processing entities of the second PPM share one or more of the following: a processing core, a data pathway, a translation lookaside buffer, and a cache.
 28. The computer readable medium of claim 21, wherein the first PPM has an n number of processing cores, where n is an integer greater than one, each of the n processing cores capable of supporting one hardware thread; and wherein the second PPM has an m number of processing cores, wherein m is an integer greater than one, each of the m processing cores capable of supporting a p number of hardware threads, where p is an integer greater than one.
 29. The computer readable medium of claim 28, wherein the first abstraction indicates that the first PPM provides an n number of logical processing entities, and wherein the second abstraction indicates that the second PPM provides an s number of logical processing entities, where s=m times p.
 30. The computer readable medium of claim 29, wherein the operational information of the first abstraction includes resource sharing information indicating one or more resources shared by the n logical processing entities of the first PPM, and wherein the operational information of the second abstraction includes resource sharing information indicating one or more resources shared by at least some of the s logical processing entities of the second PPM.
 31. The computer readable medium of claim 30, wherein the resource sharing information of the first abstraction indicates that the n logical processing entities of the first PPM share a cache, and wherein the resource sharing information of the second abstraction indicates that at least some of the s logical processing entities of the second PPM share one or more of the following: a processing core, a data pathway, a translation lookaside buffer, and a cache.
 32. The computer readable medium of claim 21, wherein the first PPM has a single processing core capable of supporting an n number of hardware threads, where n is an integer greater than one; and wherein the second PPM has an m number of processing cores, wherein m is an integer greater than one, each of the m processing cores capable of supposing a p number of hardware threads, where p is an integer greater than one.
 33. The computer readable medium of claim 32, wherein the first abstraction indicates that the first PPM provides an n number of logical processing entities, and wherein the second abstraction indicates that the second PPM provides an s number of logical processing entities, where s=m times p.
 34. The computer readable storage medium of claim 33, wherein the operational information of the first abstraction includes resource sharing information indicating one or more resources shared by the n logical processing entities of the first PPM, and wherein the operational information of the second abstraction includes resource sharing information indicating one or more resources shared by at least some of the s logical processing entities of the second PPM.
 35. The computer readable medium of claim 34, wherein the resource sharing information of the first abstraction indicates that the n logical processing entities of the first PPM share one or more of the following: a processing core, a data pathway, a translation lookaside buffer, and a cache, and wherein the resource sharing information of the second abstraction indicates that at least some of the s logical processing entities of the second PPM share one or more of the following: a processing core, a data pathway, a translation lookaside buffer, and a cache.
 36. The computer readable medium of claim 21, wherein the instructions cause the computer system to further perform the operations of: accessing the first abstraction and/or the second abstraction.
 37. The computer readable medium of claim 36, wherein the operational information of the first abstraction includes resource sharing information indicating one or more resources shared by the logical processing entities of the first PPM, and wherein the operational information of the second abstraction includes resource sharing information indicating one or more resources shared by the logical processing entities of the second PPM.
 38. The computer readable medium of claim 37, wherein determining whether to dispatch an execution thread comprises: determining, based at least partially upon the resource sharing information in the first abstraction and/or the resource sharing information in the second abstraction, whether to dispatch an execution thread to one of the logical processing entities of the first PPM or one of the logical processing entities of the second PPM to be executed thereby.
 39. The computer readable medium of claim 38, wherein the resource sharing information in the first abstraction indicates that the logical processing entities of the first PPM are sharing one or more of the following: a processing core, a data pathway, a translation lookaside buffer, and a cache.
 40. The computer readable medium of claim 39, wherein the resource sharing information in the second abstraction indicates that the logical processing entities of the second PPM are sharing one or more of the following: a processing core, a data pathway, a translation lookaside buffer, and a cache.
 41. A computer system comprising: a first physical processing module (PPM) having a first architecture; an operating system executing within the computer system, wherein the operating system performs the operations of: receiving a first set of parametric information pertaining to the first PPM; constructing a first abstraction of the first PPM based, at least partially, upon the first set of parametric information, the first abstraction comprising an indication of how many logical processing entities are provided by the first PPM, the first abstraction further comprising operational information indicating one or more operational characteristics of the first PPM; determining that a second abstraction for a second PPM does not exist, the second PPM having a second architecture wherein the first architecture is different from the second architecture; receiving a second set of parametric information pertaining to the second PPM; constructing a second abstraction of the second PPM based, at least partially, upon the second set of parametric information, the second abstraction comprising an indication of how many logical processing entities are provided by the second PPM, the second abstraction further comprising operational information indicating one or more operational characteristics of the second PPM, wherein the second abstraction is different from the first abstraction to reflect the differences between the first architecture of the first PPM and the second architecture of the second PPM; and dispatching, based on the at least one difference between the first architecture of the first PPM and the second architecture of the second PPM and the operational information in the first abstraction, an execution thread for execution to one of the logical processing entities of the first PPM.
 42. The computer system of claim 41, wherein the first PPM comprises a first physical processing core which supports a single hardware thread, wherein the second PPM comprises a second physical processing core which supports a plurality of hardware threads, wherein constructing the first abstraction comprises indicating the first physical processing core as a single logical processing entity, and wherein constructing the second abstraction comprises indicating the second physical processing core as a plurality of logical processing entities.
 43. The computer system of claim 42, wherein constructing the second abstraction comprises indicating that the plurality of logical processing entities corresponding to the second physical processing core share one or more resources of the second PPM.
 44. The computer system of claim 41, wherein the first PPM has an n number of processing cores, where n is an integer greater than one, each of the n processing cores capable of supporting one hardware thread; and wherein the second PPM has a single processing core capable of supporting an m number of hardware threads, where m is an integer greater than one.
 45. The computer system of claim 44, wherein the first abstraction indicates that the first PPM provides an n number of logical processing entities, and wherein the second abstraction indicates that the second PPM provides an m number of logical processing entities.
 46. The computer system of claim 45, wherein the operational information of the first abstraction includes resource sharing information indicating one or more resources shared by the n logical processing entities of the first PPM, and wherein the operational information of the second abstraction includes resource sharing information indicating one or more resources shared by the m logical processing entities of the second PPM.
 47. The computer system of claim 46, wherein the resource sharing information of the first abstraction indicates that the n logical processing entities of the first PPM share a cache, and wherein the resource sharing information of the second abstraction indicates that the m logical processing entities of the second PPM share one or more of the following: a processing core, a data pathway, a translation lookaside buffer, and a cache.
 48. The computer system of claim 41, wherein the first PPM has an n number of processing cores, where n is an integer greater than one, each of the n processing cores capable of supporting one hardware thread; and wherein the second PPM has an m number of processing cores, wherein m is an integer greater than one, each of the m processing cores capable of supporting a p number of hardware threads, where p is an integer greater than one.
 49. The computer system of claim 48, wherein the first abstraction indicates that the first PPM provides an n number of logical processing entities, and wherein the second abstraction indicates that the second PPM provides an s number of logical processing entities, where s=m times p.
 50. The computer system of claim 49, wherein the operational information of the first abstraction includes resource sharing information indicating one or more resources shared by the n logical processing entities of the first PPM, and wherein the operational information of the second abstraction includes resource sharing information indicating one or more resources shared by at least some of the s logical processing entities of the second PPM.
 51. The computer system of claim 50, wherein the resource sharing information of the first abstraction indicates that the n logical processing entities of the first PPM share a cache, and wherein the resource sharing information of the second abstraction indicates that at least some of the s logical processing entities of the second PPM share one or more of the following: a processing core, a data pathway, a translation lookaside buffer, and a cache.
 52. The computer system of claim 41, wherein the first PPM has a single processing core capable of supporting an n number of hardware threads, where n is an integer greater than one; and wherein the second PPM has an m number of processing cores, wherein m is an integer greater than one, each of the m processing cores capable of supporting a p number of hardware threads, where p is an integer greater than one.
 53. The computer system of claim 52, wherein the first abstraction indicates that the first PPM provides an n number of logical processing entities, and wherein the second abstraction indicates that the second PPM provides an s number of logical processing entities, where s=m times p.
 54. The computer system of claim 53, wherein the operational information of the first abstraction includes resource sharing information indicating one or more resources shared by the n logical processing entities of the first PPM, and wherein the operational information of the second abstraction includes resource sharing information indicating one or more resources shared by at least some of the s logical processing entities of the second PPM.
 55. The computer system of claim 54, wherein the resource sharing information of the first abstraction indicates that the n logical processing entities of the first PPM share one or more of the following: a processing core, a data pathway, a translation lookaside buffer, and a cache, and wherein the resource sharing information of the second abstraction indicates that at least some of the s logical processing entities of the second PPM share one or more of the following: a processing core, a data pathway, a translation lookaside buffer, and a cache.
 56. The computer system of claim 41, wherein the operating system further performs the operations of: accessing the first abstraction and/or the second abstraction.
 57. The computer system of claim 56, wherein the operational information of the first abstraction includes resource sharing information indicating one or more resources shared by the logical processing entities of the first PPM, and wherein the operational information of the second abstraction includes resource sharing information indicating one or more resources shared by the logical processing entities of the second PPM.
 58. The computer system of claim 57, wherein determining whether to dispatch an execution thread comprises: determining, based at least partially upon the resource sharing information in the first abstraction and/or the resource sharing information in the second abstraction, whether to dispatch an execution thread to one of the logical processing entities of the first PPM or one of the logical processing entities of the second PPM to be executed thereby.
 59. The computer system of claim 58, wherein the resource sharing information in the first abstraction indicates that the logical processing entities of the first PPM are sharing one or more of the following: a processing core, a data pathway, a translation lookaside buffer, and a cache.
 60. The computer system of claim 59, wherein the resource sharing information in the second abstraction indicates that the logical processing entities of the second PPM are sharing one or more of the following: a processing core, a data pathway, a translation lookaside buffer, and a cache. 